/**
 * ***************************************************************************** Copyright (c) 2000,
 * 2010 IBM Corporation and others. All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0 which accompanies this
 * distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 *
 * <p>Contributors: IBM Corporation - initial API and implementation
 * *****************************************************************************
 */
package org.eclipse.che.ide.ext.java.jdt.core.dom;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * Modifier node.
 *
 * <p>
 *
 * <pre>
 * Modifier:
 *    <b>public</b>
 *    <b>protected</b>
 *    <b>private</b>
 *    <b>static</b>
 *    <b>abstract</b>
 *    <b>final</b>
 *    <b>native</b>
 *    <b>synchronized</b>
 *    <b>transient</b>
 *    <b>volatile</b>
 *    <b>strictfp</b>
 * </pre>
 *
 * <p>The numeric values of these flags match the ones for class files as described in the Java
 * Virtual Machine Specification. Note that Java model class {@link org.eclipse.jdt.core.Flags} also
 * provides the same constants as this class.
 *
 * @noinstantiate This class is not intended to be instantiated by clients.
 * @since 2.0
 */
public final class Modifier /*extends ASTNode implements IExtendedModifier*/ {

  /**
   * Modifier keywords (typesafe enumeration).
   *
   * @since 3.0
   */
  public static class ModifierKeyword {

    /** "abstract" modifier with flag value {@link Modifier#ABSTRACT}. */
    public static final ModifierKeyword ABSTRACT_KEYWORD =
        new ModifierKeyword("abstract", ABSTRACT); // $NON-NLS-1$

    /** "final" modifier with flag value {@link Modifier#FINAL}. */
    public static final ModifierKeyword FINAL_KEYWORD =
        new ModifierKeyword("final", FINAL); // $NON-NLS-1$

    /**
     * Map from token to operator (key type: <code>String</code>; value type: <code>Operator</code>
     * ).
     */
    private static final Map KEYWORDS;

    /** "native" modifier with flag value {@link Modifier#NATIVE}. */
    public static final ModifierKeyword NATIVE_KEYWORD =
        new ModifierKeyword("native", NATIVE); // $NON-NLS-1$

    /** "private" modifier with flag value {@link Modifier#PRIVATE}. */
    public static final ModifierKeyword PRIVATE_KEYWORD =
        new ModifierKeyword("private", PRIVATE); // $NON-NLS-1$

    /** "protected" modifier with flag value {@link Modifier#PROTECTED}. */
    public static final ModifierKeyword PROTECTED_KEYWORD =
        new ModifierKeyword("protected", PROTECTED); // $NON-NLS-1$

    /** "public" modifier with flag value {@link Modifier#PUBLIC}. */
    public static final ModifierKeyword PUBLIC_KEYWORD =
        new ModifierKeyword("public", PUBLIC); // $NON-NLS-1$

    /** "static" modifier with flag value {@link Modifier#STATIC}. */
    public static final ModifierKeyword STATIC_KEYWORD =
        new ModifierKeyword("static", STATIC); // $NON-NLS-1$

    /** "strictfp" modifier with flag value {@link Modifier#STRICTFP}. */
    public static final ModifierKeyword STRICTFP_KEYWORD =
        new ModifierKeyword("strictfp", STRICTFP); // $NON-NLS-1$

    /** "synchronized" modifier with flag value {@link Modifier#SYNCHRONIZED}. */
    public static final ModifierKeyword SYNCHRONIZED_KEYWORD =
        new ModifierKeyword("synchronized", SYNCHRONIZED); // $NON-NLS-1$

    /** "transient" modifier with flag value {@link Modifier#TRANSIENT}. */
    public static final ModifierKeyword TRANSIENT_KEYWORD =
        new ModifierKeyword("transient", TRANSIENT); // $NON-NLS-1$

    /** "volatile" modifier with flag value {@link Modifier#VOLATILE}. */
    public static final ModifierKeyword VOLATILE_KEYWORD =
        new ModifierKeyword("volatile", VOLATILE); // $NON-NLS-1$

    static {
      KEYWORDS = new HashMap(20);
      ModifierKeyword[] ops = {
        PUBLIC_KEYWORD,
        PROTECTED_KEYWORD,
        PRIVATE_KEYWORD,
        STATIC_KEYWORD,
        ABSTRACT_KEYWORD,
        FINAL_KEYWORD,
        NATIVE_KEYWORD,
        SYNCHRONIZED_KEYWORD,
        TRANSIENT_KEYWORD,
        VOLATILE_KEYWORD,
        STRICTFP_KEYWORD
      };
      for (int i = 0; i < ops.length; i++) {
        KEYWORDS.put(ops[i].toString(), ops[i]);
      }
    }

    /**
     * Returns the modifier corresponding to the given single-bit flag value, or <code>null</code>
     * if none or if more than one bit is set.
     *
     * <p><code>fromFlagValue</code> is the converse of <code>toFlagValue</code>: that is, <code>
     * ModifierKind.fromFlagValue(k.toFlagValue()) == k</code> for all modifier keywords <code>k
     * </code>.
     *
     * @param flagValue the single-bit flag value for the modifier
     * @return the modifier keyword, or <code>null</code> if none
     * @see #toFlagValue()
     */
    public static ModifierKeyword fromFlagValue(int flagValue) {
      for (Iterator it = KEYWORDS.values().iterator(); it.hasNext(); ) {
        ModifierKeyword k = (ModifierKeyword) it.next();
        if (k.toFlagValue() == flagValue) {
          return k;
        }
      }
      return null;
    }

    /**
     * Returns the modifier corresponding to the given string, or <code>null</code> if none.
     *
     * <p><code>toKeyword</code> is the converse of <code>toString</code>: that is, <code>
     * ModifierKind.toKeyword(k.toString()) == k</code> for all modifier keywords <code>k</code>.
     *
     * @param keyword the lowercase string name for the modifier
     * @return the modifier keyword, or <code>null</code> if none
     * @see #toString()
     */
    public static ModifierKeyword toKeyword(String keyword) {
      return (ModifierKeyword) KEYWORDS.get(keyword);
    }

    /** The flag value for the modifier. */
    private int flagValue;

    /** The keyword modifier string. */
    private String keyword;

    /**
     * Creates a new modifier with the given keyword.
     *
     * <p>Note: this constructor is private. The only instances ever created are the ones for the
     * standard modifiers.
     *
     * @param keyword the character sequence for the modifier
     * @param flagValue flag value as described in the Java Virtual Machine Specification
     */
    private ModifierKeyword(String keyword, int flagValue) {
      this.keyword = keyword;
      this.flagValue = flagValue;
    }

    /**
     * Returns the modifier flag value corresponding to this modifier keyword. These flag values are
     * as described in the Java Virtual Machine Specification.
     *
     * @return one of the <code>Modifier</code> constants
     * @see #fromFlagValue(int)
     */
    public int toFlagValue() {
      return this.flagValue;
    }

    /**
     * Returns the keyword for the modifier.
     *
     * @return the keyword for the modifier
     * @see #toKeyword(String)
     */
    public String toString() {
      return this.keyword;
    }
  }

  /**
   * "abstract" modifier constant (bit mask). Applicable to types and methods.
   *
   * @since 2.0
   */
  public static final int ABSTRACT = 0x0400;

  /**
   * "final" modifier constant (bit mask). Applicable to types, methods, fields, and variables.
   *
   * @since 2.0
   */
  public static final int FINAL = 0x0010;

  //    /**
  //     * The "keyword" structural property of this node type (type: {@link
  // Modifier.ModifierKeyword}).
  //     *
  //     * @since 3.0
  //     */
  //    public static final SimplePropertyDescriptor KEYWORD_PROPERTY = new
  // SimplePropertyDescriptor(Modifier.class,
  //
  // "keyword", Modifier.ModifierKeyword.class,
  //
  // MANDATORY); //$NON-NLS-1$

  /**
   * "native" modifier constant (bit mask). Applicable only to methods.
   *
   * @since 2.0
   */
  public static final int NATIVE = 0x0100;

  /**
   * Modifier constant (bit mask, value 0) indicating no modifiers.
   *
   * @since 2.0
   */
  public static final int NONE = 0x0000;

  /**
   * "private" modifier constant (bit mask). Applicable to types, methods, constructors, and fields.
   *
   * @since 2.0
   */
  public static final int PRIVATE = 0x0002;

  //    /** A list of property descriptors (element type: {@link StructuralPropertyDescriptor}), or
  // null if uninitialized. */
  //    private static final List PROPERTY_DESCRIPTORS;

  /**
   * "protected" modifier constant (bit mask). Applicable to types, methods, constructors, and
   * fields.
   *
   * @since 2.0
   */
  public static final int PROTECTED = 0x0004;

  /**
   * "public" modifier constant (bit mask). Applicable to types, methods, constructors, and fields.
   *
   * @since 2.0
   */
  public static final int PUBLIC = 0x0001;

  /**
   * "static" modifier constant (bit mask). Applicable to types, methods, fields, and initializers.
   *
   * @since 2.0
   */
  public static final int STATIC = 0x0008;

  /**
   * "strictfp" modifier constant (bit mask). Applicable to types and methods.
   *
   * @since 2.0
   */
  public static final int STRICTFP = 0x0800;

  /**
   * "synchronized" modifier constant (bit mask). Applicable only to methods.
   *
   * @since 2.0
   */
  public static final int SYNCHRONIZED = 0x0020;

  /**
   * "transient" modifier constant (bit mask). Applicable only to fields.
   *
   * @since 2.0
   */
  public static final int TRANSIENT = 0x0080;

  /**
   * "volatile" modifier constant (bit mask). Applicable only to fields.
   *
   * @since 2.0
   */
  public static final int VOLATILE = 0x0040;

  //    static {
  //        List properyList = new ArrayList(2);
  //        createPropertyList(Modifier.class, properyList);
  //        addProperty(KEYWORD_PROPERTY, properyList);
  //        PROPERTY_DESCRIPTORS = reapPropertyList(properyList);
  //    }

  /**
   * Returns whether the given flags includes the "abstract" modifier. Applicable to types and
   * methods.
   *
   * @param flags the modifier flags
   * @return <code>true</code> if the <code>ABSTRACT</code> bit is set, and <code>false</code>
   *     otherwise
   * @since 2.0
   */
  public static boolean isAbstract(int flags) {
    return (flags & ABSTRACT) != 0;
  }

  /**
   * Returns whether the given flags includes the "final" modifier. Applicable to types, methods,
   * fields, and variables.
   *
   * @param flags the modifier flags
   * @return <code>true</code> if the <code>FINAL</code> bit is set, and <code>false</code>
   *     otherwise
   * @since 2.0
   */
  public static boolean isFinal(int flags) {
    return (flags & FINAL) != 0;
  }

  /**
   * Returns whether the given flags includes the "native" modifier. Applicable only to methods.
   *
   * @param flags the modifier flags
   * @return <code>true</code> if the <code>NATIVE</code> bit is set, and <code>false</code>
   *     otherwise
   * @since 2.0
   */
  public static boolean isNative(int flags) {
    return (flags & NATIVE) != 0;
  }

  /**
   * Returns whether the given flags includes the "private" modifier. Applicable to types, methods,
   * constructors, and fields.
   *
   * @param flags the modifier flags
   * @return <code>true</code> if the <code>PRIVATE</code> bit is set, and <code>false</code>
   *     otherwise
   * @since 2.0
   */
  public static boolean isPrivate(int flags) {
    return (flags & PRIVATE) != 0;
  }

  /**
   * Returns whether the given flags includes the "protected" modifier. Applicable to types,
   * methods, constructors, and fields.
   *
   * @param flags the modifier flags
   * @return <code>true</code> if the <code>PROTECTED</code> bit is set, and <code>false</code>
   *     otherwise
   * @since 2.0
   */
  public static boolean isProtected(int flags) {
    return (flags & PROTECTED) != 0;
  }

  /**
   * Returns whether the given flags includes the "public" modifier. Applicable to types, methods,
   * constructors, and fields.
   *
   * @param flags the modifier flags
   * @return <code>true</code> if the <code>PUBLIC</code> bit is set, and <code>false</code>
   *     otherwise
   * @since 2.0
   */
  public static boolean isPublic(int flags) {
    return (flags & PUBLIC) != 0;
  }

  /**
   * Returns whether the given flags includes the "static" modifier. Applicable to types, methods,
   * fields, and initializers.
   *
   * @param flags the modifier flags
   * @return <code>true</code> if the <code>STATIC</code> bit is set, and <code>false</code>
   *     otherwise
   * @since 2.0
   */
  public static boolean isStatic(int flags) {
    return (flags & STATIC) != 0;
  }

  /**
   * Returns whether the given flags includes the "strictfp" modifier. Applicable to types and
   * methods.
   *
   * @param flags the modifier flags
   * @return <code>true</code> if the <code>STRICTFP</code> bit is set, and <code>false</code>
   *     otherwise
   * @since 2.0
   */
  public static boolean isStrictfp(int flags) {
    return (flags & STRICTFP) != 0;
  }

  /**
   * Returns whether the given flags includes the "synchronized" modifier. Applicable only to
   * methods.
   *
   * @param flags the modifier flags
   * @return <code>true</code> if the <code>SYNCHRONIZED</code> bit is set, and <code>false</code>
   *     otherwise
   * @since 2.0
   */
  public static boolean isSynchronized(int flags) {
    return (flags & SYNCHRONIZED) != 0;
  }

  /**
   * Returns whether the given flags includes the "transient" modifier. Applicable only to fields.
   *
   * @param flags the modifier flags
   * @return <code>true</code> if the <code>TRANSIENT</code> bit is set, and <code>false</code>
   *     otherwise
   * @since 2.0
   */
  public static boolean isTransient(int flags) {
    return (flags & TRANSIENT) != 0;
  }

  /**
   * Returns whether the given flags includes the "volatile" modifier. Applicable only to fields.
   *
   * @param flags the modifier flags
   * @return <code>true</code> if the <code>VOLATILE</code> bit is set, and <code>false</code>
   *     otherwise
   * @since 2.0
   */
  public static boolean isVolatile(int flags) {
    return (flags & VOLATILE) != 0;
  }

  //    /**
  //     * Returns a list of structural property descriptors for this node type. Clients must not
  // modify the result.
  //     *
  //     * @param apiLevel
  //     *         the API level; one of the <code>AST.JLS*</code> constants
  //     * @return a list of property descriptors (element type: {@link
  // StructuralPropertyDescriptor})
  //     * @since 3.0
  //     */
  //    public static List propertyDescriptors(int apiLevel) {
  //        return PROPERTY_DESCRIPTORS;
  //    }

  /**
   * The modifier keyword; defaults to an unspecified modifier.
   *
   * @since 3.0
   */
  private ModifierKeyword modifierKeyword = ModifierKeyword.PUBLIC_KEYWORD;

  //    /**
  //     * Creates a new unparented modifier node owned by the given AST. By default, the node has
  // unspecified (but legal) modifier.
  //     * <p>
  //     * N.B. This constructor is package-private.
  //     * </p>
  //     *
  //     * @param ast
  //     *         the AST that is to own this node
  //     * @since 3.0
  //     */
  //    Modifier(AST ast) {
  //        super(ast);
  //        unsupportedIn2();
  //    }
  //
  //    /*
  //     * (omit javadoc for this method) Method declared on ASTNode.
  //     * @since 3.0
  //     */
  //    void accept0(ASTVisitor visitor) {
  //        visitor.visit(this);
  //        visitor.endVisit(this);
  //    }
  //
  //    /*
  //     * (omit javadoc for this method) Method declared on ASTNode.
  //     * @since 3.0
  //     */
  //    ASTNode clone0(AST target) {
  //        Modifier result = new Modifier(target);
  //        result.setSourceRange(getStartPosition(), getLength());
  //        result.setKeyword(getKeyword());
  //        return result;
  //    }
  //
  //    /**
  //     * Returns the modifier keyword of this modifier node.
  //     *
  //     * @return the modifier keyword
  //     * @since 3.0
  //     */
  //    public ModifierKeyword getKeyword() {
  //        return this.modifierKeyword;
  //    }
  //
  //    /*
  //     * (omit javadoc for this method) Method declared on ASTNode.
  //     * @since 3.0
  //     */
  //    final int getNodeType0() {
  //        return MODIFIER;
  //    }
  //
  //    /* (omit javadoc for this method) Method declared on ASTNode. */
  //    final Object internalGetSetObjectProperty(SimplePropertyDescriptor property, boolean get,
  // Object value) {
  //        if (property == KEYWORD_PROPERTY) {
  //            if (get) {
  //                return getKeyword();
  //            } else {
  //                setKeyword((ModifierKeyword)value);
  //                return null;
  //            }
  //        }
  //        // allow default implementation to flag the error
  //        return super.internalGetSetObjectProperty(property, get, value);
  //    }
  //
  //    /* (omit javadoc for this method) Method declared on ASTNode. */
  //    final List internalStructuralPropertiesForType(int apiLevel) {
  //        return propertyDescriptors(apiLevel);
  //    }
  //
  //    /**
  //     * Answer true if the receiver is the abstract modifier, false otherwise.
  //     *
  //     * @return true if the receiver is the abstract modifier, false otherwise
  //     * @since 3.2
  //     */
  //    public boolean isAbstract() {
  //        return this.modifierKeyword == ModifierKeyword.ABSTRACT_KEYWORD;
  //    }
  //
  //    /** @see IExtendedModifier#isAnnotation() */
  //    public boolean isAnnotation() {
  //        return false;
  //    }
  //
  //    /**
  //     * Answer true if the receiver is the final modifier, false otherwise.
  //     *
  //     * @return true if the receiver is the final modifier, false otherwise
  //     * @since 3.2
  //     */
  //    public boolean isFinal() {
  //        return this.modifierKeyword == ModifierKeyword.FINAL_KEYWORD;
  //    }
  //
  //    /** @see IExtendedModifier#isModifier() */
  //    public boolean isModifier() {
  //        return true;
  //    }
  //
  //    /**
  //     * Answer true if the receiver is the native modifier, false otherwise.
  //     *
  //     * @return true if the receiver is the native modifier, false otherwise
  //     * @since 3.2
  //     */
  //    public boolean isNative() {
  //        return this.modifierKeyword == ModifierKeyword.NATIVE_KEYWORD;
  //    }
  //
  //    /**
  //     * Answer true if the receiver is the private modifier, false otherwise.
  //     *
  //     * @return true if the receiver is the private modifier, false otherwise
  //     * @since 3.2
  //     */
  //    public boolean isPrivate() {
  //        return this.modifierKeyword == ModifierKeyword.PRIVATE_KEYWORD;
  //    }
  //
  //    /**
  //     * Answer true if the receiver is the protected modifier, false otherwise.
  //     *
  //     * @return true if the receiver is the protected modifier, false otherwise
  //     * @since 3.2
  //     */
  //    public boolean isProtected() {
  //        return this.modifierKeyword == ModifierKeyword.PROTECTED_KEYWORD;
  //    }
  //
  //    /**
  //     * Answer true if the receiver is the public modifier, false otherwise.
  //     *
  //     * @return true if the receiver is the public modifier, false otherwise
  //     * @since 3.2
  //     */
  //    public boolean isPublic() {
  //        return this.modifierKeyword == ModifierKeyword.PUBLIC_KEYWORD;
  //    }
  //
  //    /**
  //     * Answer true if the receiver is the static modifier, false otherwise.
  //     *
  //     * @return true if the receiver is the static modifier, false otherwise
  //     * @since 3.2
  //     */
  //    public boolean isStatic() {
  //        return this.modifierKeyword == ModifierKeyword.STATIC_KEYWORD;
  //    }
  //
  //    /**
  //     * Answer true if the receiver is the strictfp modifier, false otherwise.
  //     *
  //     * @return true if the receiver is the strictfp modifier, false otherwise
  //     * @since 3.2
  //     */
  //    public boolean isStrictfp() {
  //        return this.modifierKeyword == ModifierKeyword.STRICTFP_KEYWORD;
  //    }
  //
  //    /**
  //     * Answer true if the receiver is the synchronized modifier, false otherwise.
  //     *
  //     * @return true if the receiver is the synchronized modifier, false otherwise
  //     * @since 3.2
  //     */
  //    public boolean isSynchronized() {
  //        return this.modifierKeyword == ModifierKeyword.SYNCHRONIZED_KEYWORD;
  //    }
  //
  //    /**
  //     * Answer true if the receiver is the transient modifier, false otherwise.
  //     *
  //     * @return true if the receiver is the transient modifier, false otherwise
  //     * @since 3.2
  //     */
  //    public boolean isTransient() {
  //        return this.modifierKeyword == ModifierKeyword.TRANSIENT_KEYWORD;
  //    }
  //
  //    /**
  //     * Answer true if the receiver is the volatile modifier, false otherwise.
  //     *
  //     * @return true if the receiver is the volatile modifier, false otherwise
  //     * @since 3.2
  //     */
  //    public boolean isVolatile() {
  //        return this.modifierKeyword == ModifierKeyword.VOLATILE_KEYWORD;
  //    }
  //
  //    /*
  //     * (omit javadoc for this method) Method declared on ASTNode.
  //     * @since 3.0
  //     */
  //    int memSize() {
  //        // treat ModifierKeyword as free
  //        return BASE_NODE_SIZE + 1 * 4;
  //    }
  //
  //    /**
  //     * Sets the modifier keyword of this modifier node.
  //     *
  //     * @param modifierKeyord
  //     *         the modifier keyword
  //     * @throws IllegalArgumentException
  //     *         if the argument is <code>null</code>
  //     * @since 3.0
  //     */
  //    public void setKeyword(ModifierKeyword modifierKeyord) {
  //        if (modifierKeyord == null) {
  //            throw new IllegalArgumentException();
  //        }
  //        preValueChange(KEYWORD_PROPERTY);
  //        this.modifierKeyword = modifierKeyord;
  //        postValueChange(KEYWORD_PROPERTY);
  //    }
  //
  //    /*
  //     * (omit javadoc for this method) Method declared on ASTNode.
  //     * @since 3.0
  //     */
  //    final boolean subtreeMatch0(ASTMatcher matcher, Object other) {
  //        // dispatch to correct overloaded match method
  //        return matcher.match(this, other);
  //    }
  //
  //    /*
  //     * (omit javadoc for this method) Method declared on ASTNode.
  //     * @since 3.0
  //     */
  //    int treeSize() {
  //        return memSize();
  //    }
}
